La seguente tesi è stata scritta interamente su R Markdown. Poichè alcuni pacchetti non sono presenti su Word ho deciso di creare una copia della tesi in html, consultabile tramite questo link, oppure scannerizzando il qr code riportato in basso.
Si presume che abbiate già installato R (https://www.r-project.org) (R Core Team 2023) e l’IDE RStudio (https://www.rstudio.com). RStudio non è obbligatorio ma consigliato, perché rende più facile per un utente medio lavorare con R Markdown. Se non avete installato l’IDE RStudio, dovrete installare Pandoc (http://pandoc.org), altrimenti non c’è bisogno di installare Pandoc separatamente perché RStudio lo ha fornito in bundle. Quindi si può installare il pacchetto rmarkdown in R.
Se si vuole generare un output PDF, è necessario installare LaTeX. Agli utenti di R Markdown che non hanno mai installato LaTeX, consigliamo di installare TinyTeX (https://yihui.name/tinytex/).
R Markdown è un pacchetto gratuito di R che offre un framework completo per l’autoreferenzialità nella scienza dei dati. Consente di utilizzare un unico file R Markdown sia per scrivere ed eseguire codice, sia per generare report di alta qualità, facilmente condivisibili con chiunque.
Questo strumento è stato progettato per promuovere la riproducibilità, poiché combina il codice di calcolo e la narrazione all’interno dello stesso documento, generando automaticamente i risultati a partire dal codice sorgente. R Markdown supporta numerosi formati di output, sia statici che dinamici/interattivi.
È possibile creare un file di testo di questo tipo utilizzando qualsiasi editor, incluso RStudio. Se si utilizza RStudio, è sufficiente selezionare “File” dal menu, poi “New file” e infine “R Markdown” per creare un nuovo file Rmd.
Un documento R Markdown è composto da tre elementi fondamentali: i metadati, il testo e il codice. I metadati sono racchiusi tra due coppie di tre trattini (—). La sintassi dei metadati è in formato YAML, motivo per cui vengono talvolta chiamati “metadati YAML” o “frontmatter YAML”.
È importante notare che l’indentazione è fondamentale in YAML; quindi, assicurati di indentare correttamente i sottocampi rispetto ai campi superiori.
Il corpo di un documento R Markdown segue i metadati. La sintassi per il testo, conosciuta anche come prosa o narrativa, è in Markdown. Ci sono due tipi di codice:
Un blocco di codice inizia con tre trattini inversi, come
({r}), dove “r” indica il linguaggio utilizzato, e
termina anch’esso con tre trattini inversi. All’interno delle parentesi
graffe è possibile specificare le opzioni del chunk; ad esempio, per
impostare l’altezza della figura a 5 pollici, si scrive {r,
fig.height=5}.
Inoltre, un’espressione di codice R inline inizia con r e termina con un backtick . La figura 1 mostra l’output in RStudio.
…
Il modo più comune per compilare un documento R Markdown è cliccare sul pulsante Knit, il corrispondente collegamento da tastiera è Ctrl + Shift + K (Cmd + Shift + K su macOS). In pratica, RStudio utilizza la funzione rmarkdown::render() per elaborare il documento in una nuova sessione di R. È importante notare che questo aspetto spesso crea confusione tra gli utenti di R Markdown: rendere un documento Rmd in una nuova sessione significa che nessuno degli oggetti della sessione R attuale (come quelli creati nella console di R) sarà accessibile in quella nuova sessione. La riproducibilità è la ragione principale per cui RStudio adotta questo metodo: spesso si desidera che i documenti funzionino anche quando si riapre R o in ambienti di calcolo diversi.
Se hai bisogno di elaborare un documento nella sessione corrente di R, puoi anche chiamare tu stesso rmarkdown::render() e fornire il percorso del file Rmd come argomento. Il secondo argomento è il formato di output, che di default corrisponde al primo formato specificato nei metadati YAML (se assente, il default è html_document). Se hai più formati di output nei metadati e non vuoi utilizzare il primo, puoi specificare quello che preferisci come secondo argomento; ad esempio, per un documento Rmd chiamato foo.Rmd con i metadati:
’’’{r}
output:
html_document:
toc: true
pdf_document:
keep_tex: true
’’’
Puoi quindi compilarlo in PDF con:
’’’{r}
rmarkdown::render(‘foo.Rmd’, ‘pdf_document’)
’’’
Questa chiamata alla funzione ti offre maggiore flessibilità (ad esempio, puoi generare una serie di report in un ciclo), ma è fondamentale considerare la riproducibilità quando utilizzi questo metodo. Naturalmente, puoi avviare una nuova sessione R pulita e chiamare rmarkdown::render() in quella sessione. Se non interagisci manualmente con quella sessione (come creando variabili nella console), i tuoi report dovrebbero rimanere riproducibili.
È importante notare che è possibile generare una serie di report da un singolo documento R Markdown, parametrizzando il documento stesso e creando report diversi utilizzando parametri differenti.
Markdown è un linguaggio di markup che consente di scrivere testo formattato in modo semplice e leggibile. Quando scrivi in R Markdown, usi la sintassi di Markdown per formattare il testo, inserire link, immagini, tabelle, liste e così via, senza dover usare HTML o altri linguaggi di markup complessi.
Ecco una panoramica più dettagliata della sintassi Markdown che puoi usare all’interno di un documento R Markdown.
Le intestazioni servono per strutturare il documento e indicare i vari livelli di titoli o sezioni. In Markdown, puoi creare intestazioni usando il simbolo # seguito dal testo del titolo. Più # metti, più il livello del titolo è basso. Sono previsti fino a sei livelli di titoli.
In Markdown, puoi formattare il testo per renderlo in grassetto, in corsivo, o barra attraverso (per cancellare una parola). Ecco come:
Testo in grassetto Testo in grassetto
Testo in corsivo Testo in corsivo
Grassetto e Corsivo
Testo barrato
Markdown supporta due tipi di liste: non ordinate (puntate) e ordinate (numerate).
lista non ordinata:Usa asterischi *, plus + o meno - per creare punti di lista.
Punto 1
Punto 2
Punto 3
Puoi anche usare + o - al posto di *:
Esempio di lista annidata:
Punto 1
Punto 2
lista ordinata:Usa numeri seguiti da un punto per creare una lista numerata.
Le liste numerate supportano anche l’annidamento:
Link:Per creare un link, usa la sintassi testo del link: Google
Immagini: La sintassi per le immagini è simile
ai link, ma con un punto esclamativo davanti.
Risultato: (inserisce l’immagine se il link è valido)
Markdown permette anche di formattare le citazioni utilizzando il simbolo >. Questo è utile per includere estratti di testo, citazioni o note.
> “La scienza è un modo di pensare molto più che un insieme di conoscenze.” – Carl Sagan
Risultato:
“La scienza è un modo di pensare molto più che un insieme di conoscenze.” – Carl Sagan
Markdown ti consente di formattare anche il codice, che è una delle caratteristiche principali in R Markdown. Puoi inserire il codice inline (una singola riga di codice) e i blocchi di codice (più righe di codice).
Il codice x <- rnorm(100) genera 100 numeri casuali.
Oltre ai chunk di codice, puoi anche inserire i valori degli oggetti R inline nel testo. Ad esempio:
x = 5 # raggio di un cerchio
Per un cerchio con raggio 5, la sua area è 78.5398163.
x <- rnorm(100)
hist(x)
Risultato: Mostra il codice in un blocco di codice, che può essere eseguito (in R Markdown).
Le tabelle in Markdown possono essere create usando pipe (|) e trattini (-) per definire le righe e le colonne.
| Intestazione 1 | Intestazione 2 |
|---|---|
| Riga 1 Col 1 | Riga 1 Col 2 |
| Riga 2 Col 1 | Riga 2 Col 2 |
Come nel caso di formule matematiche inline o su più righe, utilizzando il formato \[ ... \] o $ … $.
\[\begin{array}{ccc} x_{11} & x_{12} & x_{13}\\ x_{21} & x_{22} & x_{23} \end{array}\]
\[\Theta = \begin{pmatrix}\alpha & \beta\\ \gamma & \delta \end{pmatrix}\]
Le opzioni di knitr in R Markdown sono impostazioni che controllano come il codice R è eseguito e come i suoi risultati vengono visualizzati nel documento finale. Le opzioni di knitr sono specificate nei blocchi di codice R all’interno del documento, subito dopo l’apertura del blocco (tra le parentesi graffe). Queste opzioni ti permettono di personalizzare il comportamento di ogni blocco di codice, come l’esecuzione del codice, la visualizzazione del codice, l’output dei grafici e altro ancora.
Un blocco di codice R in R Markdown ha la seguente sintassi:
{r opzioni}
# Codice R qui
Le opzioni di knitr sono specificate come coppie nome = valore dentro le parentesi graffe, separate da virgole.
Ci sono molte opzioni di chunk in knitr documentate su https://yihui.name/knitr/options. Elenchiamo un sottoinsieme di esse di seguito:
1.echo:
Descrizione: Controlla se il codice deve essere mostrato nel documento finale.
Valori:
’’’{r, echo=FALSE}
x <- 1:10
y <- x^2
plot(x, y)
’’’
2.eval:
Descrizione: Determina se il codice deve essere eseguito o meno.
Valori:
’’’{r, eval=FALSE}
x <- rnorm(100)
summary(x)
’’’
3.message:
Descrizione: Controlla se i messaggi (come
quelli generati dalla funzione message()) devono essere
visualizzati.
Valori:
’’’{r, message=FALSE}
message(“Questo è un messaggio di prova”)
’’’
Il messaggio non apparirà nel documento finale.
4.warning:
Descrizione: Controlla se gli avvisi (come
quelli generati dalla funzione warning()) devono essere
visualizzati.
Valori:
’’’{r, warning=FALSE}
warning(“Questo è un avviso”)
’’’
L’avviso non verrà visualizzato nel documento finale.
5.results:
Descrizione: Determina come i risultati del codice devono essere visualizzati.
Valori:
’’‘{r, results=’asis’}
summary(cars)
’’’
In questo caso, i risultati del comando summary(cars)
verranno visualizzati senza modifiche.
6.fig.show:
Descrizione: Controlla quando la figura deve essere mostrata.
Valori:
’’‘{r, fig.show=’hide’}
plot(1:10)
’’’
La figura non verrà mostrata nel documento finale.
7.out.width e out.height:
Descrizione: Controllano la larghezza e l’altezza dell’immagine nel documento di output.
Valori:Le dimensioni desiderate per l’immagine (ad esempio in percentuale o in unità fisiche come in, cm, ecc.).
’’‘{r, out.width=’50%’}
plot(1:10)
’’’
La figura non verrà mostrata nel documento finale.
8.fig.align: * Descrizione: Controlla l’allineamento delle immagini nel documento.
’’‘{r, fig.align=’center’}
plot(1:10)
’’’
Il grafico verrà centrato nella pagina.
9.cache:
Descrizione: Controlla se i risultati di un blocco di codice devono essere memorizzati nella cache per evitarne il ricalcolo nelle esecuzioni successive.
Valori:
’’’{r, cache=FALSE}
x <- rnorm(100)
mean(x)
’’’
Questo blocco memorizza nella cache il risultato della funzione
mean(x), quindi non dovrà essere ricalcolato in una
esecuzione successiva del documento.
10.collapse:
Descrizione: L’opzione collapse è
utilizzata per determinare se il codice e i risultati devono essere
uniti in un unico blocco di testo o separati su più righe.
Valori:
Questa opzione è utile per migliorare la leggibilità, specialmente quando il codice e l’output sono di piccole dimensioni.
’’’{r, collapse=TRUE}
x <- 1:5
y <- x^2
x
y
’’’
Con collapse=TRUE, il codice e i risultati vengono visualizzati insieme senza interruzione tra le righe.
Se invece usi collapse=FALSE, ogni linea di codice e di risultato sarà separata.
’’’{r, collapse=FALSE}
x <- 1:5
y <- x^2
x
y
’’’
11.include:
Descrizione: L’opzione include controlla se il blocco di codice e i suoi risultati devono essere inclusi nel documento finale.
Valori:
Questa opzione è utile se vuoi eseguire codice ma non vuoi che appaia nel documento finale.
’’’{r, include=FALSE}
x <- rnorm(100)
summary(x)
’’’
In questo caso, il codice verrà eseguito, ma né il codice né l’output appariranno nel documento finale.
12.dev:
Descrizione: L’opzione dev specifica il dispositivo grafico da utilizzare per la creazione di immagini (grafici). Viene utilizzata per salvare i grafici in diversi formati.
Valori:
’’‘{r, dev=’png’}
plot(1:10, main=“Grafico in PNG”)
’’’
In questo caso, il grafico verrà salvato come immagine PNG con le dimensioni specificate.
13.fig.cap:
Descrizione: L’opzione fig.cap consente di aggiungere una didascalia (caption) a un grafico o figura.
Valori:
Questa opzione è utile quando vuoi aggiungere un commento o una descrizione ai grafici nel documento finale.
’’’{r, fig.cap=“grafico della funzione
quadratica”}
x <- 1:10
y <- x^2
plot(x, y)
’’’
Il grafico sarà accompagnato dalla didascalia “Grafico della funzione quadratica” nel documento finale.
14.child:
Descrizione: L’opzione child è usata per includere un altro file R Markdown come un “figlio” all’interno del documento corrente. Il file figlio può essere un intero documento R Markdown che viene eseguito e incluso nel documento principale.
Valori:
Questa opzione è utile per creare documenti modulari, in cui si desidera includere un documento R Markdown separato in un altro documento.
Esempio: Immagina di avere un documento R Markdown principale (main.Rmd) e un documento figlio (child.Rmd).
main.Rmd {r, }
child.Rmd ’’’{r, child=main.Rmd}
summary(cars)
’’’
Quando il documento principale (main.Rmd) viene eseguito, il codice e l’output di child.Rmd verranno inclusi nel documento finale.
R Markdown supporta una vasta gamma di formati di output per creare documenti in vari formati, inclusi HTML, PDF, Word, Microsoft PowerPoint, LaTeX, Beamer e altri. Ogni formato ha il suo scopo e può essere configurato con diverse opzioni di personalizzazione, a seconda delle esigenze del documento. Di seguito, esplorerò i principali formati di output che puoi utilizzare con R Markdown e le principali opzioni per ogni tipo di output.
output: html_document
Esempio:
output:
—
html_document:
toc: true # Aggiunge un sommario (table of
contents)
toc_depth: 2 # Imposta la profondità del sommario
theme: united # Tema della pagina
—
Altri formati HTML: R Markdown supporta anche formati HTML avanzati come:
output: pdf_document
Esempio:
—
output:
pdf_document:
toc: true # Aggiunge un sommario
number_sections: true # Numerazione automatica delle
sezioni
latex_engine: xelatex # Usa xelatex per il motore
LaTeX
—
Il formato Word consente di generare documenti Microsoft Word direttamente da R Markdown, utili per report aziendali o documenti che devono essere modificati facilmente.
output: word_document
Esempio:
—
output:
word_document:
toc: true # Aggiunge un sommario
reference_docx: “template.docx” # Usa un documento di template
per stili personalizzati
—
output: powerpoint_presentation
Esempio:
—
output:
powerpoint_presentation:
slide_level: 2 # Imposta il livello di intestazione per le
slide
transition: fade # Aggiunge la transizione fade tra le
slide
—
output: beamer_presentation
Esempio:
—
output:
beamer_presentation:
theme: Madrid # Imposta il tema delle slide
colortheme: seahorse # Imposta il tema di colore
—
output: html_document
output: latex_document
Esempio:
—
output:
latex_document:
highlight: tango # Imposta il tema di evidenziazione del
codice
keep_tex: true # Mantiene il file .tex
—
output: output: pandoc_document
In R Markdown, puoi scrivere e eseguire diversi tipi di codice di programmazione oltre a R, grazie alla sua integrazione con diversi linguaggi di programmazione. I vari tipi di programmazione che puoi usare in R Markdown sono:
R Markdown è pensato principalmente per lavorare con R, il linguaggio di programmazione per l’analisi statistica e la visualizzazione dei dati. I chunk di codice R sono quelli più comuni in R Markdown e ti permettono di eseguire operazioni statistiche, manipolazioni dei dati, grafici e tanto altro.
R Markdown permette di eseguire codice Python tramite l’integrazione con reticulate, un pacchetto che permette di eseguire codice Python all’interno di R Markdown. Puoi usare Python per l’analisi dei dati, la creazione di grafici, l’uso di modelli di machine learning, ecc.
Esempio di un chunk di codice Python:
’’’{python}
import numpy as np
x = np.random.randn(100)
np.mean(x)
’’’
Per eseguire Python in R Markdown, dovrai avere Python installato e configurare reticulate per l’integrazione tra R e Python.
Puoi eseguire query SQL direttamente da R Markdown utilizzando il pacchetto DBI o strumenti specifici come RSQLite o pool. Questo è utile quando si lavora con database relazionali e si desidera eseguire operazioni SQL direttamente nel documento.
’’’{sql connection=}
SELECT * FROM my_table WHERE column > 10
’’’
R Markdown supporta anche l’esecuzione di comandi di shell. Se stai lavorando in un ambiente Unix-like (come Linux o macOS), puoi eseguire comandi shell direttamente nel tuo documento per interagire con il sistema operativo, gestire file, installare pacchetti e molto altro.
*Esempio di un chunk di shell:
’’’{bash}
echo “Ciao, mondo!”
ls -l
’’’
Puoi eseguire JavaScript nei tuoi documenti R Markdown, particolarmente utile per documenti HTML, dove hai bisogno di interattività sul lato client. Ad esempio, puoi usare JavaScript per creare interazioni più avanzate o animazioni in un documento HTML.
’’’{js}
console.log(“Hello from JavaScript”)
’’’
Anche se R Markdown non esegue direttamente CSS come codice, puoi includere e personalizzare il tuo documento HTML con il CSS. Puoi usare CSS per stilizzare l’aspetto del tuo documento, modificando il layout, i colori, i caratteri e altri aspetti visivi.
’’’{css}
body {
font-family: Arial, sans-serif;
}
’’’
Puoi includere codice LaTeX nei tuoi documenti R Markdown per scrivere formule matematiche e simboli. LaTeX è particolarmente utile per documenti scientifici o tecnici che richiedono una notazione matematica avanzata.
’’’{markdown}
begin{equation} E = mc^2 end{equation}
}
’’’
R Markdown supporta anche altri linguaggi di programmazione grazie a pacchetti che permettono l’esecuzione di codice in questi linguaggi. Per esempio, eseguire Haskell, Julia, Ruby e altri linguaggi è possibile, ma richiede configurazioni aggiuntive, come l’uso di reticulate o di pacchetti di interfaccia specifici.
’’’{julia}
using Random
x = randn(100)
mean(x)
’’’
Allo stesso modo di Haskell e Julia, è possibile eseguire linguaggi come Groovy, Perl, Scala e altri, ma richiedono l’installazione di pacchetti di interfaccia specifici per R Markdown.
’’’{groovy}
println “Hello from Groovy”
’’’
Shiny è un framework per costruire applicazioni web interattive in R. Puoi integrare Shiny nei tuoi documenti R Markdown per creare documenti interattivi, dove l’utente può interagire con i dati e visualizzazioni in tempo reale, tramite controlli come slider, pulsanti e altri widget.
R Markdown supporta anche linguaggi come C e C++ tramite l’interfaccia con il pacchetto Rcpp. Questo ti permette di scrivere codice ad alte prestazioni direttamente nei tuoi documenti R Markdown.
// [[Rcpp::export]]
NumericVector add_one(NumericVector x) {
return x + 1;
}
)
’’’
library(lattice)
data(mpg)
xyplot(hwy ~ displ | class, data = mpg, layout = c(3, 2))
library(highcharter)
## Registered S3 method overwritten by 'quantmod':
## method from
## as.zoo.data.frame zoo
##
## Caricamento pacchetto: 'highcharter'
## Il seguente oggetto è mascherato da 'package:flextable':
##
## colorize
data(mpg)
hchart(mpg, "scatter", hcaes(x = displ, y = hwy, group = class)) %>%
hc_title(text = "Relazione tra cilindrata e consumo")
library(DiagrammeR)
grViz("
digraph boxes_and_circles {
a [shape = box]
b [shape = circle]
a -> b
}
")
library(leaflet)
leaflet() %>%
addTiles() %>%
addMarkers(lng = 11.2462600, lat = 43.7792500,
popup = "Qui è Firenze")
library(rgl)
plot3d(mtcars$wt, mtcars$mpg, mtcars$hp,
col = "red", size = 3)
Il pacchetto flextable per R è uno strumento potente per creare e formattare tabelle avanzate in documenti R Markdown, con un supporto particolare per l’esportazione in Word e HTML. È particolarmente utile quando desideri tabelle ben formattate e stilizzate, che vanno oltre le capacità di base di knitr::kable() o xtable. Con flextable, puoi facilmente personalizzare l’aspetto delle tabelle con stili complessi, colori, formati di testo, bordi, e altro ancora.
esempio 1
evidenziare la tabella mtcars Questo esempio crea una tabella stilizzata utilizzando il pacchetto flextable, che permette di visualizzare i dati in modo più leggibile e personalizzabile ed aggiunge una nota sotto la tabella.
library(flextable)
set_flextable_defaults(
font.family = "Arial", font.size = 10,
border.color = "gray", big.mark = "")
ft <- flextable(head(mtcars)) |>
bold(part = "header")
ft
mpg | cyl | disp | hp | drat | wt | qsec | vs | am | gear | carb |
|---|---|---|---|---|---|---|---|---|---|---|
21.0 | 6 | 160 | 110 | 3.90 | 2.620 | 16.46 | 0 | 1 | 4 | 4 |
21.0 | 6 | 160 | 110 | 3.90 | 2.875 | 17.02 | 0 | 1 | 4 | 4 |
22.8 | 4 | 108 | 93 | 3.85 | 2.320 | 18.61 | 1 | 1 | 4 | 1 |
21.4 | 6 | 258 | 110 | 3.08 | 3.215 | 19.44 | 1 | 0 | 3 | 1 |
18.7 | 8 | 360 | 175 | 3.15 | 3.440 | 17.02 | 0 | 0 | 3 | 2 |
18.1 | 6 | 225 | 105 | 2.76 | 3.460 | 20.22 | 1 | 0 | 3 | 1 |
ft |>
highlight(i = ~ mpg < 22, j = "disp", color = "#ffe842") |>
bg(j = c("hp", "drat", "wt"),
bg = scales::col_quantile(palette = c("wheat", "red"), domain =NULL)) |>
add_footer_lines("The 'mtcars' dataset")
## Warning: Skewed data means we can only allocate 4 unique colours not the 4
## requested
mpg | cyl | disp | hp | drat | wt | qsec | vs | am | gear | carb |
|---|---|---|---|---|---|---|---|---|---|---|
21.0 | 6 | 160 | 110 | 3.90 | 2.620 | 16.46 | 0 | 1 | 4 | 4 |
21.0 | 6 | 160 | 110 | 3.90 | 2.875 | 17.02 | 0 | 1 | 4 | 4 |
22.8 | 4 | 108 | 93 | 3.85 | 2.320 | 18.61 | 1 | 1 | 4 | 1 |
21.4 | 6 | 258 | 110 | 3.08 | 3.215 | 19.44 | 1 | 0 | 3 | 1 |
18.7 | 8 | 360 | 175 | 3.15 | 3.440 | 17.02 | 0 | 0 | 3 | 2 |
18.1 | 6 | 225 | 105 | 2.76 | 3.460 | 20.22 | 1 | 0 | 3 | 1 |
The 'mtcars' dataset | ||||||||||
esempio 2 Viene creata una funzione che permetta di associare un colore di sfondo alle celle in base al valore della correlazione corrispondente.
La funzione assocerà un colore utilizzando la funzione cut().
# correlations ----
library(dplyr)
##
## Allegato package : 'dplyr'
## I seguenti oggetti sono nascosti da 'package:stats':
##
## filter, lag
## I seguenti oggetti sono nascosti da 'package:base':
##
## intersect, setdiff, setequal, union
library(tibble)
correlations <- cor(mtcars) |>
as.data.frame() |>
rownames_to_column(var = "rowname")
correlations
## rowname mpg cyl disp hp drat wt
## 1 mpg 1.0000000 -0.8521620 -0.8475514 -0.7761684 0.68117191 -0.8676594
## 2 cyl -0.8521620 1.0000000 0.9020329 0.8324475 -0.69993811 0.7824958
## 3 disp -0.8475514 0.9020329 1.0000000 0.7909486 -0.71021393 0.8879799
## 4 hp -0.7761684 0.8324475 0.7909486 1.0000000 -0.44875912 0.6587479
## 5 drat 0.6811719 -0.6999381 -0.7102139 -0.4487591 1.00000000 -0.7124406
## 6 wt -0.8676594 0.7824958 0.8879799 0.6587479 -0.71244065 1.0000000
## 7 qsec 0.4186840 -0.5912421 -0.4336979 -0.7082234 0.09120476 -0.1747159
## 8 vs 0.6640389 -0.8108118 -0.7104159 -0.7230967 0.44027846 -0.5549157
## 9 am 0.5998324 -0.5226070 -0.5912270 -0.2432043 0.71271113 -0.6924953
## 10 gear 0.4802848 -0.4926866 -0.5555692 -0.1257043 0.69961013 -0.5832870
## 11 carb -0.5509251 0.5269883 0.3949769 0.7498125 -0.09078980 0.4276059
## qsec vs am gear carb
## 1 0.41868403 0.6640389 0.59983243 0.4802848 -0.55092507
## 2 -0.59124207 -0.8108118 -0.52260705 -0.4926866 0.52698829
## 3 -0.43369788 -0.7104159 -0.59122704 -0.5555692 0.39497686
## 4 -0.70822339 -0.7230967 -0.24320426 -0.1257043 0.74981247
## 5 0.09120476 0.4402785 0.71271113 0.6996101 -0.09078980
## 6 -0.17471588 -0.5549157 -0.69249526 -0.5832870 0.42760594
## 7 1.00000000 0.7445354 -0.22986086 -0.2126822 -0.65624923
## 8 0.74453544 1.0000000 0.16834512 0.2060233 -0.56960714
## 9 -0.22986086 0.1683451 1.00000000 0.7940588 0.05753435
## 10 -0.21268223 0.2060233 0.79405876 1.0000000 0.27407284
## 11 -0.65624923 -0.5696071 0.05753435 0.2740728 1.00000000
## rowname mpg cyl disp hp drat wt
## 1 mpg 1.0000000 -0.8521620 -0.8475514 -0.7761684 0.68117191 -0.8676594
## 2 cyl -0.8521620 1.0000000 0.9020329 0.8324475 -0.69993811 0.7824958
## 3 disp -0.8475514 0.9020329 1.0000000 0.7909486 -0.71021393 0.8879799
## 4 hp -0.7761684 0.8324475 0.7909486 1.0000000 -0.44875912 0.6587479
## 5 drat 0.6811719 -0.6999381 -0.7102139 -0.4487591 1.00000000 -0.7124406
## 6 wt -0.8676594 0.7824958 0.8879799 0.6587479 -0.71244065 1.0000000
## 7 qsec 0.4186840 -0.5912421 -0.4336979 -0.7082234 0.09120476 -0.1747159
## 8 vs 0.6640389 -0.8108118 -0.7104159 -0.7230967 0.44027846 -0.5549157
## 9 am 0.5998324 -0.5226070 -0.5912270 -0.2432043 0.71271113 -0.6924953
## 10 gear 0.4802848 -0.4926866 -0.5555692 -0.1257043 0.69961013 -0.5832870
## 11 carb -0.5509251 0.5269883 0.3949769 0.7498125 -0.09078980 0.4276059
## qsec vs am gear carb
## 1 0.41868403 0.6640389 0.59983243 0.4802848 -0.55092507
## 2 -0.59124207 -0.8108118 -0.52260705 -0.4926866 0.52698829
## 3 -0.43369788 -0.7104159 -0.59122704 -0.5555692 0.39497686
## 4 -0.70822339 -0.7230967 -0.24320426 -0.1257043 0.74981247
## 5 0.09120476 0.4402785 0.71271113 0.6996101 -0.09078980
## 6 -0.17471588 -0.5549157 -0.69249526 -0.5832870 0.42760594
## 7 1.00000000 0.7445354 -0.22986086 -0.2126822 -0.65624923
## 8 0.74453544 1.0000000 0.16834512 0.2060233 -0.56960714
## 9 -0.22986086 0.1683451 1.00000000 0.7940588 0.05753435
## 10 -0.21268223 0.2060233 0.79405876 1.0000000 0.27407284
## 11 -0.65624923 -0.5696071 0.05753435 0.2740728 1.00000000
cor_color <- function(x){
col_palette <- c("#D73027", "#F46D43", "#FDAE61", "#FEE08B",
"#D9EF8B", "#A6D96A", "#66BD63", "#1A9850")
mycut <- cut(x,
breaks = c(-1, -0.75, -0.5, -0.25, 0, 0.25, 0.5, 0.75, 1),
include.lowest = TRUE, label = FALSE)
col_palette[mycut]
}
std_border <- fp_border_default(color = "white")
Viene applicata la funzione cor_color() ai colori di sfondo delle celle e impostata anche una larghezza e altezza fisse per le celle, in modo da riprodurre un effetto simile a quello delle grafiche heatmap.
ft <- flextable(correlations) %>%
border_outer(part = "all", border = std_border) %>%
border_inner(border = std_border, part = "all") %>%
compose(i = 1, j = 1, value = as_paragraph(""), part = "header") %>%
compose(j = ~ . - rowname, value = as_paragraph(""), part = "body") %>%
bg(j = ~ . - rowname, bg = cor_color) %>%
height(height = .5) %>%
hrule(rule = "exact", part = "body") %>%
width(width = .5)
ft
esempio 3
tabelle demografiche con Flextable
Gli studi clinici spesso iniziano con una tabella riassuntiva delle caratteristiche demografiche dei pazienti inclusi nello studio per dimostrare un equilibrio tra i trattamenti e gli altri sottogruppi.
Il formato è standard e può essere realizzato con flextable in 2 operazioni.
I due passaggi per creare queste tabelle sono:
Riassumere le informazioni con la funzione flextable::summarizor(). Essa calcola un insieme di statistiche per ciascuna variabile per gruppi. Restituisce un data.frame pronto per essere utilizzato dalla funzione flextable::as_flextable()
Creare la flextable con la funzione as_flextable() e personalizzarla con le funzioni di flextable.
library(flextable)
library(officer)
library(tidyverse)
library(safetyData)
set_flextable_defaults(
border.color = "#AAAAAA", font.family = "Arial",
font.size = 10, padding = 2, line_spacing = 1.5
)
adsl <- select(adam_adsl, AGE, SEX, BMIBLGR1, DURDIS, ARM)
adsl
## # A tibble: 254 × 5
## AGE SEX BMIBLGR1 DURDIS ARM
## <dbl> <chr> <chr> <dbl> <chr>
## 1 63 F 25-<30 43.9 Placebo
## 2 64 M >=30 76.4 Placebo
## 3 71 M >=30 42.8 Xanomeline High Dose
## 4 74 M 25-<30 55.3 Xanomeline Low Dose
## 5 77 F 25-<30 32.9 Xanomeline High Dose
## 6 85 F >=30 42 Placebo
## 7 68 M 25-<30 99.1 Xanomeline Low Dose
## 8 81 F <25 40.7 Xanomeline Low Dose
## 9 84 M <25 102. Xanomeline Low Dose
## 10 52 M <25 44.2 Placebo
## # ℹ 244 more rows
Viene usata la funzione flextable::summarizor(). Essa produce un data.frame aggregato strutturato per flextable::as_flextable().
dat <- summarizor(adsl, by = "ARM")
dat
## variable stat value1 value2 cts percent data_type
## 1 AGE mean_sd 75.20930 8.590167 NA NA continuous
## 2 AGE median_iqr 76.00000 12.500000 NA NA continuous
## 3 AGE range 52.00000 89.000000 NA NA continuous
## 4 SEX F NA NA 53 0.61627907 discrete
## 5 SEX M NA NA 33 0.38372093 discrete
## 6 BMIBLGR1 <25 NA NA 59 0.68604651 discrete
## 7 BMIBLGR1 >=30 NA NA 6 0.06976744 discrete
## 8 BMIBLGR1 25-<30 NA NA 21 0.24418605 discrete
## 9 DURDIS mean_sd 42.65000 30.241572 NA NA continuous
## 10 DURDIS median_iqr 35.30000 25.775000 NA NA continuous
## 11 DURDIS range 7.20000 183.100000 NA NA continuous
## 12 AGE mean_sd 74.38095 7.886094 NA NA continuous
## 13 AGE median_iqr 76.00000 9.250000 NA NA continuous
## 14 AGE range 56.00000 88.000000 NA NA continuous
## 15 SEX F NA NA 40 0.47619048 discrete
## 16 SEX M NA NA 44 0.52380952 discrete
## 17 BMIBLGR1 <25 NA NA 44 0.52380952 discrete
## 18 BMIBLGR1 >=30 NA NA 12 0.14285714 discrete
## 19 BMIBLGR1 25-<30 NA NA 28 0.33333333 discrete
## 20 DURDIS mean_sd 40.50714 24.693547 NA NA continuous
## 21 DURDIS median_iqr 35.95000 28.550000 NA NA continuous
## 22 DURDIS range 2.20000 135.000000 NA NA continuous
## 23 AGE mean_sd 75.66667 8.286051 NA NA continuous
## 24 AGE median_iqr 77.50000 11.000000 NA NA continuous
## 25 AGE range 51.00000 88.000000 NA NA continuous
## 26 SEX F NA NA 50 0.59523810 discrete
## 27 SEX M NA NA 34 0.40476190 discrete
## 28 BMIBLGR1 <25 NA NA 47 0.55952381 discrete
## 29 BMIBLGR1 >=30 NA NA 10 0.11904762 discrete
## 30 BMIBLGR1 25-<30 NA NA 27 0.32142857 discrete
## 31 DURDIS mean_sd 48.69167 29.584171 NA NA continuous
## 32 DURDIS median_iqr 40.25000 39.950000 NA NA continuous
## 33 DURDIS range 7.80000 130.800000 NA NA continuous
## ARM
## 1 Placebo
## 2 Placebo
## 3 Placebo
## 4 Placebo
## 5 Placebo
## 6 Placebo
## 7 Placebo
## 8 Placebo
## 9 Placebo
## 10 Placebo
## 11 Placebo
## 12 Xanomeline High Dose
## 13 Xanomeline High Dose
## 14 Xanomeline High Dose
## 15 Xanomeline High Dose
## 16 Xanomeline High Dose
## 17 Xanomeline High Dose
## 18 Xanomeline High Dose
## 19 Xanomeline High Dose
## 20 Xanomeline High Dose
## 21 Xanomeline High Dose
## 22 Xanomeline High Dose
## 23 Xanomeline Low Dose
## 24 Xanomeline Low Dose
## 25 Xanomeline Low Dose
## 26 Xanomeline Low Dose
## 27 Xanomeline Low Dose
## 28 Xanomeline Low Dose
## 29 Xanomeline Low Dose
## 30 Xanomeline Low Dose
## 31 Xanomeline Low Dose
## 32 Xanomeline Low Dose
## 33 Xanomeline Low Dose
Viene eseguita una visualizzazione in cui i trattamenti siano distribuiti nelle colonne e dove il contenuto dei paragrafi sia abbastanza flessibile da consentire la creazione della tabella.
ft <- as_flextable(dat)
ft
Placebo | Xanomeline High Dose | Xanomeline Low Dose | |||||
|---|---|---|---|---|---|---|---|
Age | Mean (SD) | 75.2 (8.6) | 74.4 (7.9) | 75.7 (8.3) | |||
Median (IQR) | 76.0 (12.5) | 76.0 (9.2) | 77.5 (11.0) | ||||
Range | 52.0 - 89.0 | 56.0 - 88.0 | 51.0 - 88.0 | ||||
Sex | F | 53 (61.6%) | 40 (47.6%) | 50 (59.5%) | |||
M | 33 (38.4%) | 44 (52.4%) | 34 (40.5%) | ||||
Pooled Baseline BMI Group 1 | <25 | 59 (68.6%) | 44 (52.4%) | 47 (56.0%) | |||
>=30 | 6 (7.0%) | 12 (14.3%) | 10 (11.9%) | ||||
25-<30 | 21 (24.4%) | 28 (33.3%) | 27 (32.1%) | ||||
Duration of Disease (Months) | Mean (SD) | 42.6 (30.2) | 40.5 (24.7) | 48.7 (29.6) | |||
Median (IQR) | 35.3 (25.8) | 36.0 (28.6) | 40.2 (39.9) | ||||
Range | 7.2 - 183.1 | 2.2 - 135.0 | 7.8 - 130.8 |
Il metodo flextable::as_flextable() supporta gli argomenti del metodo flextable::tabulator(). Viene utilizzato l’argomento spread_first_col = TRUE per separare i nomi delle variabili con delle linee di separazione e non visualizzare più la colonna. Aggiungendo anche una didascalia e una nota in fondo alla tabella, insieme ad alcuni parametri aggiuntivi.
ft <- as_flextable(dat, spread_first_col = TRUE, separate_with = "variable") %>%
bold(i = ~ !is.na(variable), j = 1, bold = TRUE) %>%
set_caption(
autonum = officer::run_autonum(seq_id = "tab", bkm = "demo_tab", bkm_all = FALSE),
fp_p = officer::fp_par(text.align = "left", padding = 5),
align_with_table = FALSE,
caption = as_paragraph(
"Demographic Characteristics",
"\nx.x: Study Subject Data"
)
) %>%
add_footer_lines("Source: ADaM adsl data frame from r package 'safetyData'") %>%
fix_border_issues() %>%
autofit()
ft
Placebo | Xanomeline High Dose | Xanomeline Low Dose | ||||
|---|---|---|---|---|---|---|
AGE | ||||||
Mean (SD) | 75.2 (8.6) | 74.4 (7.9) | 75.7 (8.3) | |||
Median (IQR) | 76.0 (12.5) | 76.0 (9.2) | 77.5 (11.0) | |||
Range | 52.0 - 89.0 | 56.0 - 88.0 | 51.0 - 88.0 | |||
SEX | ||||||
F | 53 (61.6%) | 40 (47.6%) | 50 (59.5%) | |||
M | 33 (38.4%) | 44 (52.4%) | 34 (40.5%) | |||
BMIBLGR1 | ||||||
<25 | 59 (68.6%) | 44 (52.4%) | 47 (56.0%) | |||
>=30 | 6 (7.0%) | 12 (14.3%) | 10 (11.9%) | |||
25-<30 | 21 (24.4%) | 28 (33.3%) | 27 (32.1%) | |||
DURDIS | ||||||
Mean (SD) | 42.6 (30.2) | 40.5 (24.7) | 48.7 (29.6) | |||
Median (IQR) | 35.3 (25.8) | 36.0 (28.6) | 40.2 (39.9) | |||
Range | 7.2 - 183.1 | 2.2 - 135.0 | 7.8 - 130.8 | |||
Source: ADaM adsl data frame from r package 'safetyData' | ||||||
Etichette
Questa parte permette di recuperare un set di etichette che viene usato per sostituire alcuni testi visualizzati nella flextable.
La funzione da utilizzare è labelizor(), che prende come argomento un vettore nominato. I nomi sono i valori da sostituire, i valori sono i valori di sostituzione.
Vengono recuperate le etichette delle colonne memorizzate nella tabella originale.
col_labels <- map_chr(adsl, function(x) attr(x, "label"))
## AGE SEX
## "Age" "Sex"
## BMIBLGR1 DURDIS
## "Pooled Baseline BMI Group 1" "Duration of Disease (Months)"
## ARM
## "Description of Planned Arm"
ft <- labelizor(ft, j = "stat", labels = col_labels, part = "all")
ft
Placebo | Xanomeline High Dose | Xanomeline Low Dose | ||||
|---|---|---|---|---|---|---|
Age | ||||||
Mean (SD) | 75.2 (8.6) | 74.4 (7.9) | 75.7 (8.3) | |||
Median (IQR) | 76.0 (12.5) | 76.0 (9.2) | 77.5 (11.0) | |||
Range | 52.0 - 89.0 | 56.0 - 88.0 | 51.0 - 88.0 | |||
Sex | ||||||
F | 53 (61.6%) | 40 (47.6%) | 50 (59.5%) | |||
M | 33 (38.4%) | 44 (52.4%) | 34 (40.5%) | |||
Pooled Baseline BMI Group 1 | ||||||
<25 | 59 (68.6%) | 44 (52.4%) | 47 (56.0%) | |||
>=30 | 6 (7.0%) | 12 (14.3%) | 10 (11.9%) | |||
25-<30 | 21 (24.4%) | 28 (33.3%) | 27 (32.1%) | |||
Duration of Disease (Months) | ||||||
Mean (SD) | 42.6 (30.2) | 40.5 (24.7) | 48.7 (29.6) | |||
Median (IQR) | 35.3 (25.8) | 36.0 (28.6) | 40.2 (39.9) | |||
Range | 7.2 - 183.1 | 2.2 - 135.0 | 7.8 - 130.8 | |||
Source: ADaM adsl data frame from r package 'safetyData' | ||||||
La libreria formattable di R è uno strumento utile per migliorare la visualizzazione dei dati in R, specialmente quando si lavora con tabelle o dati in formato data.frame. Questa libreria permette di formattare facilmente il contenuto di una tabella, aggiungendo stili, colori e formati personalizzati per rendere più leggibile e interpretabile l’informazione. È particolarmente utile in contesti di reportistica e visualizzazione di dati in cui l’aspetto delle tabelle è importante.
Per un pratico esempio verrà utilizzato un set di dati proveniente dal Portale Open Data di Austin. Si tratta di un sito web progettato per facilitare l’accesso ai dati governativi aperti.
L’esempio riportato sotto può essere visualizzato sul documento html citato precedentemente.
Utilizzeremo formattable sul set di dati degli Indicatori di Imagine Austin. Secondo il sito web di Imagine Austin, il set di dati traccia gli indicatori di performance chiave (KPI) del progresso di Austin nella creazione di una città connessa, vivace e vivibile.
Il termine KPI (Key Performance Indicator, ovvero “Indicatore Chiave di Performance”) viene utilizzato per indicare una misura quantitativa utilizzata per valutare il successo di un’organizzazione, di un progetto o di un’azione specifica in relazione a obiettivi predefiniti. In questo contesto, viene impiegato per monitorare il progresso di Austin nel raggiungere determinati obiettivi di salute e benessere.
Nel caso specifico del set di dati di Imagine Austin, i KPI sono utilizzati per tracciare il progresso della città su vari indicatori chiave legati alla salute (come l’obesità, l’uso di tabacco, le malattie cardiovascolari, ecc.). Ogni KPI rappresenta una misura di performance in un determinato anno, come ad esempio la percentuale di obesità o il tasso di malattie cardiovascolari, che può essere monitorata nel tempo per osservare se ci sono miglioramenti o peggioramenti.
In sintesi, l’uso del termine KPI, in questo caso aiuta a identificare i dati specifici che vengono utilizzati per misurare l’efficacia degli interventi e il raggiungimento degli obiettivi di salute pubblica della città.
#Load the libraries
library(data.table)
library(dplyr)
library(formattable)
library(tidyr)
#Set a few color variables to make our table more visually appealing
customGreen0 = "#DeF7E9"
customGreen = "#71CA97"
customRed = "#ff7f7f"
#Download the Austin indicator data set
austinData= fread('https://raw.githubusercontent.com/lgellis/MiscTutorial/master/Austin/Imagine_Austin_Indicators.csv', data.table=FALSE, header = TRUE, stringsAsFactors = FALSE)
attach(austinData)
## I seguenti oggetti sono mascherati da austinData (pos = 8):
##
## #, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016,
## 2017, Data Source, Importance and Relevance to Imagine Austin,
## Indicator Description, Indicator Name, Methodology, units
Viene ridotto il set di dati per concentrarsi su 4 indicatori chiave della salute. Nello specifico: la prevalenza dell’obesità, l’uso di tabacco, le malattie cardiovascolari e l’obesità. Successivamente, selezioneremo solo le colonne contenenti il nome dell’indicatore e il valore KPI annuale. Infine, vengono create colonne aggiuntive per visualizzare la media annuale dal 2011 al 2016 e i miglioramenti degli indicatori dal 2011 al 2016.
i1 <- austinData %>%
filter(`Indicator Name` %in%
c('Prevalence of Obesity', 'Prevalence of Tobacco Use',
'Prevalence of Cardiovascular Disease', 'Prevalence of Diabetes')) %>%
select(c(`Indicator Name`, `2011`, `2012`, `2013`, `2014`, `2015`, `2016`)) %>%
mutate (Average = round(rowMeans(
cbind(`2011`, `2012`, `2013`, `2014`, `2015`, `2016`), na.rm=T),2),
`Improvement` = round((`2011`-`2016`)/`2011`*100,2))
formattable(i1)
| Indicator Name | 2011 | 2012 | 2013 | 2014 | 2015 | 2016 | Average | Improvement |
|---|---|---|---|---|---|---|---|---|
| Prevalence of Obesity | 19.1 | 23.6 | 23.3 | 20.5 | 24.0 | 23.2 | 22.28 | -21.47 |
| Prevalence of Tobacco Use | 17.4 | 15.0 | 15.3 | 12.2 | 16.6 | 16.7 | 15.53 | 4.02 |
| Prevalence of Cardiovascular Disease | 5.0 | 4.9 | 1.5 | 4.4 | 4.9 | 6.2 | 4.48 | -24.00 |
| Prevalence of Diabetes | 8.0 | 7.2 | 9.3 | 7.2 | 7.5 | 10.4 | 8.27 | -30.00 |
Viene allineata a sinistra la prima colonna, a destra l’ultima colonna e centrato il resto. Inoltre, viene messo in grassetto e in grigio il titolo della riga: “Indicator Name”.
#1) First Data Table
formattable(i1,
align =c("l","c","c","c","c", "c", "c", "c", "r"),
list(`Indicator Name` = formatter(
"span", style = ~ style(color = "grey",font.weight = "bold"))
))
| Indicator Name | 2011 | 2012 | 2013 | 2014 | 2015 | 2016 | Average | Improvement |
|---|---|---|---|---|---|---|---|---|
| Prevalence of Obesity | 19.1 | 23.6 | 23.3 | 20.5 | 24.0 | 23.2 | 22.28 | -21.47 |
| Prevalence of Tobacco Use | 17.4 | 15.0 | 15.3 | 12.2 | 16.6 | 16.7 | 15.53 | 4.02 |
| Prevalence of Cardiovascular Disease | 5.0 | 4.9 | 1.5 | 4.4 | 4.9 | 6.2 | 4.48 | -24.00 |
| Prevalence of Diabetes | 8.0 | 7.2 | 9.3 | 7.2 | 7.5 | 10.4 | 8.27 | -30.00 |
Aggiungendo la funzione color_tile a tutte le colonne
relative agli anni. Questo crea l’effetto di una heatmap riga per riga,
colonna per colonna. Notare che vengono utilizzati i colori
personalizzati dichiarati all’inizio del codice per garantire che la
tabella abbia l’aspetto che più si desidera.
#2) Add the color mapping for all 2011 to 2016.
formattable(i1, align =c("l","c","c","c","c", "c", "c", "c", "r"), list(
`Indicator Name` = formatter("span", style = ~ style(color = "grey",font.weight = "bold")),
`2011`= color_tile(customGreen, customGreen0),
`2012`= color_tile(customGreen, customGreen0),
`2013`= color_tile(customGreen, customGreen0),
`2014`= color_tile(customGreen, customGreen0),
`2015`= color_tile(customGreen, customGreen0),
`2016`= color_tile(customGreen, customGreen0)
))
| Indicator Name | 2011 | 2012 | 2013 | 2014 | 2015 | 2016 | Average | Improvement |
|---|---|---|---|---|---|---|---|---|
| Prevalence of Obesity | 19.1 | 23.6 | 23.3 | 20.5 | 24.0 | 23.2 | 22.28 | -21.47 |
| Prevalence of Tobacco Use | 17.4 | 15.0 | 15.3 | 12.2 | 16.6 | 16.7 | 15.53 | 4.02 |
| Prevalence of Cardiovascular Disease | 5.0 | 4.9 | 1.5 | 4.4 | 4.9 | 6.2 | 4.48 | -24.00 |
| Prevalence of Diabetes | 8.0 | 7.2 | 9.3 | 7.2 | 7.5 | 10.4 | 8.27 | -30.00 |
Viene aggiunta la funzione color_bar alla colonna della
media. Invece di utilizzare una heatmap, verrà visualizzato lo stesso
colore di sfondo ogni volta. Tuttavia, avrà una barra per indicare la
dimensione relativa dei valori riga per riga.
#3) Add the color bar to the average column
formattable(i1, align =c("l","c","c","c","c", "c", "c", "c", "r"), list(
`Indicator Name` = formatter("span", style = ~ style(color = "grey",font.weight = "bold")),
`2011`= color_tile(customGreen, customGreen0),
`2012`= color_tile(customGreen, customGreen0),
`2013`= color_tile(customGreen, customGreen0),
`2014`= color_tile(customGreen, customGreen0),
`2015`= color_tile(customGreen, customGreen0),
`2016`= color_tile(customGreen, customGreen0),
`Average` = color_bar(customRed)
))
| Indicator Name | 2011 | 2012 | 2013 | 2014 | 2015 | 2016 | Average | Improvement |
|---|---|---|---|---|---|---|---|---|
| Prevalence of Obesity | 19.1 | 23.6 | 23.3 | 20.5 | 24.0 | 23.2 | 22.28 | -21.47 |
| Prevalence of Tobacco Use | 17.4 | 15.0 | 15.3 | 12.2 | 16.6 | 16.7 | 15.53 | 4.02 |
| Prevalence of Cardiovascular Disease | 5.0 | 4.9 | 1.5 | 4.4 | 4.9 | 6.2 | 4.48 | -24.00 |
| Prevalence of Diabetes | 8.0 | 7.2 | 9.3 | 7.2 | 7.5 | 10.4 | 8.27 | -30.00 |
Si possono creare funzioni di formattazione in modo molto semplice. Viene applicata una leggera modifica per creare la funzione improvement_formatter, che rende il testo in grassetto e lo colora di rosso o verde personalizzato a seconda del suo valore.
#4) Add sign formatter to improvement over time
improvement_formatter <-
formatter("span",
style = x ~ style(
font.weight = "bold",
color = ifelse(x > 0, customGreen, ifelse(x < 0, customRed, "black"))))
formattable(i1, align =c("l","c","c","c","c", "c", "c", "c", "r"), list(
`Indicator Name` =
formatter("span", style = ~ style(color = "grey",font.weight = "bold")),
`2011`= color_tile(customGreen, customGreen0),
`2012`= color_tile(customGreen, customGreen0),
`2013`= color_tile(customGreen, customGreen0),
`2014`= color_tile(customGreen, customGreen0),
`2015`= color_tile(customGreen, customGreen0),
`2016`= color_tile(customGreen, customGreen0),
`Average` = color_bar(customRed),
`Improvement` = improvement_formatter
))
| Indicator Name | 2011 | 2012 | 2013 | 2014 | 2015 | 2016 | Average | Improvement |
|---|---|---|---|---|---|---|---|---|
| Prevalence of Obesity | 19.1 | 23.6 | 23.3 | 20.5 | 24.0 | 23.2 | 22.28 | -21.47 |
| Prevalence of Tobacco Use | 17.4 | 15.0 | 15.3 | 12.2 | 16.6 | 16.7 | 15.53 | 4.02 |
| Prevalence of Cardiovascular Disease | 5.0 | 4.9 | 1.5 | 4.4 | 4.9 | 6.2 | 4.48 | -24.00 |
| Prevalence of Diabetes | 8.0 | 7.2 | 9.3 | 7.2 | 7.5 | 10.4 | 8.27 | -30.00 |
E’ possibile modifcare leggermente il formato per visualizzare le frecce su e giù a seconda del valore del miglioramento. Notare che nel codice sopra, viene cambiato anche il formattatore per mostrare un simbolo del pollice in su sul valore di miglioramento vincente.
#5) For improvement formatter add icons
# Up and down arrow with greater than comparison from the vignette
improvement_formatter <- formatter("span",
style = x ~ style(font.weight = "bold",
color = ifelse(x > 0, customGreen, ifelse(x < 0, customRed, "black"))),
x ~ icontext(ifelse(x>0, "arrow-up", "arrow-down"), x)
)
formattable(i1, align =c("l","c","c","c","c", "c", "c", "c", "r"), list(
`Indicator Name` = formatter("span", style = ~ style(color = "grey",font.weight = "bold")),
`2011`= color_tile(customGreen, customGreen0),
`2012`= color_tile(customGreen, customGreen0),
`2013`= color_tile(customGreen, customGreen0),
`2014`= color_tile(customGreen, customGreen0),
`2015`= color_tile(customGreen, customGreen0),
`2016`= color_tile(customGreen, customGreen0),
`Average` = color_bar(customRed),
`Improvement` = improvement_formatter
))
| Indicator Name | 2011 | 2012 | 2013 | 2014 | 2015 | 2016 | Average | Improvement |
|---|---|---|---|---|---|---|---|---|
| Prevalence of Obesity | 19.1 | 23.6 | 23.3 | 20.5 | 24.0 | 23.2 | 22.28 | -21.47 |
| Prevalence of Tobacco Use | 17.4 | 15.0 | 15.3 | 12.2 | 16.6 | 16.7 | 15.53 | 4.02 |
| Prevalence of Cardiovascular Disease | 5.0 | 4.9 | 1.5 | 4.4 | 4.9 | 6.2 | 4.48 | -24 |
| Prevalence of Diabetes | 8.0 | 7.2 | 9.3 | 7.2 | 7.5 | 10.4 | 8.27 | -30 |
E’ possibile modificare la tabella, aggiungendo simboli per visualizzare quale kpi risulta migliore.
#6) Add a star to the max value. Use if/else value = max(value)
improvement_formatter <- formatter("span",
style = x ~ style(font.weight = "bold",
color = ifelse(x > 0, customGreen, ifelse(x < 0, customRed, "black"))),
x ~ icontext(ifelse(x == max(x), "thumbs-up", ""), x)
)
## Based on Name
formattable(i1, align =c("l","c","c","c","c", "c", "c", "c", "r"), list(
`Indicator Name` = formatter("span",
style = x ~ style(color = "gray"),
x ~ icontext(ifelse(x == "Prevalence of Tobacco Use", "star", ""), x)),
`2011`= color_tile(customGreen, customGreen0),
`2012`= color_tile(customGreen, customGreen0),
`2013`= color_tile(customGreen, customGreen0),
`2014`= color_tile(customGreen, customGreen0),
`2015`= color_tile(customGreen, customGreen0),
`2016`= color_tile(customGreen, customGreen0),
`Average` = color_bar(customRed),
`Improvement` = improvement_formatter
))
| Indicator Name | 2011 | 2012 | 2013 | 2014 | 2015 | 2016 | Average | Improvement |
|---|---|---|---|---|---|---|---|---|
| Prevalence of Obesity | 19.1 | 23.6 | 23.3 | 20.5 | 24.0 | 23.2 | 22.28 | -21.47 |
| Prevalence of Tobacco Use | 17.4 | 15.0 | 15.3 | 12.2 | 16.6 | 16.7 | 15.53 | 4.02 |
| Prevalence of Cardiovascular Disease | 5.0 | 4.9 | 1.5 | 4.4 | 4.9 | 6.2 | 4.48 | -24 |
| Prevalence of Diabetes | 8.0 | 7.2 | 9.3 | 7.2 | 7.5 | 10.4 | 8.27 | -30 |
Infine, è possibile fare un semplice confronto riga per riga tra colonne. Prendendo lo stesso set di dati, viene ridotto ai soli dati del 2015 e del 2016. Confrontando quindi i valori e segnalando la colonna del 2016 come “su/giù” e verde/rossa, basandosi sul confronto del valore del 2016 con quello del 2015.
##7) Compare column to column
#Drop the rest and show just 2015 and 2016
i2 <- austinData %>%
filter(`Indicator Name` %in% c('Prevalence of Obesity', 'Prevalence of Tobacco Use', 'Prevalence of Cardiovascular Disease', 'Prevalence of Diabetes')) %>%
select(c(`Indicator Name`, `2015`, `2016`))
formattable(i2, align =c("l","c","c"), list(
`Indicator Name` = formatter("span",style = ~ style(color = "gray")),
`2016`= formatter("span", style = ~ style(color = ifelse(`2016`>`2015`, "red", "green")), ~ icontext(ifelse(`2016` >`2015`,"arrow-up", "arrow-down"), `2016`))
))
| Indicator Name | 2015 | 2016 |
|---|---|---|
| Prevalence of Obesity | 24.0 | 23.2 |
| Prevalence of Tobacco Use | 16.6 | 16.7 |
| Prevalence of Cardiovascular Disease | 4.9 | 6.2 |
| Prevalence of Diabetes | 7.5 | 10.4 |